{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "WJ9jprifq1aH"
   },
   "source": [
    "<meta name=\"description\" content=\"Upload and test ML models securely on BlindAI server: Ensure user data privacy and security during AI model deployment.\">\n",
    "\n",
    "<div id=\"colab_button\">\n",
    "  <h1>Uploading models</h1>\n",
    "  <a target=\"_blank\" href=\"https://colab.research.google.com/github/mithril-security/blindai/blob/main/docs/docs/tutorials/core/uploading_models.ipynb\"> \n",
    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "</div>\n",
    "\n",
    "_____________________________________________________________________\n",
    "\n",
    "You've tested and installed BlindAI? Time to upload your model on your server instance! \n",
    "\n",
    "You can do it in two lines of code using our Python API, but first your model will need to be converted to the Open Neural Network Exchange Format (ONNX) format. This is because ONNX is a standard enabling framework interoperability, allowing you to easily move models between different machine learning libraries.\n",
    "\n",
    "In this tutorial, we will show you how to take models from two of the most popular ML libraries, `PyTorch` and `TensorFlow`, convert them to ONNX format, and upload them to BlindAI.\n",
    "\n",
    "Let's dive in!\n",
    "\n",
    "## Pre Requisites\n",
    "_______________________________________\n",
    "\n",
    "### Installing required dependencies\n",
    "\n",
    "Unless you're are running this notebook on [Google Colab](https://colab.research.google.com/github/mithril-security/blindai/blob/main/docs/docs/tutorials/core/uploading_models.ipynb), you'll need to have [`Python`](https://www.python.org/downloads/) (3.8 or greater) and [`pip`](https://pypi.org/project/pip/) installed to run this notebook.\n",
    "\n",
    "Then, you'll need to install the BlindAI package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "1QfZ_wCDq1aO"
   },
   "outputs": [],
   "source": [
    "# install blindai package\n",
    "!pip install blindai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o7qOIOeGq1aR"
   },
   "source": [
    "We will also need to install some additional dependencies for this notebook:\n",
    "\n",
    "- [`torch`](https://pytorch.org/): to demonstrate ONNX conversion for PyTorch models\n",
    "- [`tensorflow`](https://www.tensorflow.org/), `tensorflow_hub`(https://tfhub.dev/) and `tf2onnx`(https://github.com/onnx/tensorflow-onnx) and [`numpy`](https://numpy.org/): to demonstrate ONNX conversion for TensorFlow models\n",
    "- [`urllib`](https://docs.python.org/3/library/urllib.html), [`PIL`](https://pillow.readthedocs.io/en/stable/), [`torchvision`](https://pytorch.org/vision/stable/index.html), and [`matplotlib`](https://matplotlib.org/) to download and display images used to test our models.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Sj1reMjcq1aS"
   },
   "outputs": [],
   "source": [
    "# install all other required packages\n",
    "!pip install torch tensorflow tf2onnx numpy torchvision urllib PIL matplotlib"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "jNqop7P1q1aT"
   },
   "source": [
    "### Launch the BlindAI server\n",
    "\n",
    "Let's launch an instance of BlindAI's server so we can upload the model. \n",
    "\n",
    "For the purposes of this tutorial, we will be using the `blindai.testing` server which has been designed for testing purposes *only*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CeAdSP9sq1aU",
    "outputId": "50d81661-fcad-45cb-cea9-ccb5d9b0d21e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BlindAI mock server (version 0.0.8) already installed\n"
     ]
    }
   ],
   "source": [
    "# import testing submodule\n",
    "import blindai.testing\n",
    "\n",
    "# start the server\n",
    "srv = blindai.testing.start_mock_server()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EcUQX6kLq1aV"
   },
   "source": [
    ">Note that the blindai testing module launches the server in simulation mode. As a result, it doesn't provide hardware protection and **must not be used in production**. We created this option to enable users to quickly and easily test BlindAI without needing to run the server on a machine with Intel SGX hardware. To learn more about how to run the server with hardware protections on, see [our documentation](https://blindai.mithrilsecurity.io/en/latest/)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "ZwlQXoK5q1aX"
   },
   "source": [
    "## PyTorch model\n",
    "__________________\n",
    "\n",
    "We will use the pretrained `resnet18` neural network as our example model for this section. The `resnet18` model classifies images and returns possible labels for the image with their probability of being the correct label.\n",
    "\n",
    "### Download the model\n",
    "\n",
    "We'll download the model from `PyTorch Hub`, by using the `hub` module's `load()` method. \n",
    "\n",
    "The first argument we provide specifies the GitHub repo and directory where the model can be installed from. The second specifies the name of the model to be downloaded. Then we set the `pretrained` option to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rqgVfzcIq1aY",
    "outputId": "e327fbf3-97f5-408b-a805-f66347665b83"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using cache found in /root/.cache/torch/hub/pytorch_vision_v0.10.0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "model = torch.hub.load(\"pytorch/vision:v0.10.0\", \"resnet18\", pretrained=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9T_WfYvVq1aZ"
   },
   "source": [
    "Before exporting, it's very important to ensure the model is set to inference mode. We do that by calling `model.eval()` or `model.train(False)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WOroadheq1aa",
    "outputId": "1e6f8cab-378c-4950-edd9-a5475526e22b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet(\n",
       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU(inplace=True)\n",
       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (layer1): Sequential(\n",
       "    (0): BasicBlock(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "    (1): BasicBlock(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "  )\n",
       "  (layer2): Sequential(\n",
       "    (0): BasicBlock(\n",
       "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): BasicBlock(\n",
       "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "  )\n",
       "  (layer3): Sequential(\n",
       "    (0): BasicBlock(\n",
       "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): BasicBlock(\n",
       "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "  )\n",
       "  (layer4): Sequential(\n",
       "    (0): BasicBlock(\n",
       "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): BasicBlock(\n",
       "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (fc): Linear(in_features=512, out_features=1000, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.eval()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "wvhySJQpq1ab"
   },
   "source": [
    "### ONNX conversion\n",
    "\n",
    "To convert our model to ONNX format, we will use the `torch.onnx.export()` function.\n",
    "\n",
    "The `export()` method will execute the model and record a trace of what operators are used to compute the outputs. In order for `export` to be able to perform this \"dry-run\", we need to supply it with some dummy inputs in the shape the model would expect.\n",
    "\n",
    "For `resnet18`, the dummy input should be in the following format: `batch_size`, `channel_width`, `image_size`, `image_size`.\n",
    "\n",
    "The values we provide for each dimension, in this case `batch_size`, `channel_width`, `image_size` and `image_size` will be fixed in the exported ONNX graph, meaning all future input to the model must match this shape. For example, if we set the `batch_size` to 1, users will only be able to upload one image at a time to be inferred by the model.\n",
    "\n",
    "There is a way to avoid having to set a fixed value though, by specifying that a certain axes is a dynamic axes in the `export` options. For example, if we specify `batch_size` as a dynamic axes, users will be able to upload one or multiple images to the model at a time.\n",
    "\n",
    "Let's create our dummy input now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "-EW3YnrMq1ac"
   },
   "outputs": [],
   "source": [
    "# create dummy inputs for resnet18 model\n",
    "dummy_inputs = torch.zeros(1, 3, 224, 224)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C-hAX8Pjq1ac"
   },
   "source": [
    "The channel width should be `3, representing the RGB values of our image, and the image size should be `224x224`. \n",
    "\n",
    "We will set the `batch_size` to `1`, but then specify the first dimension as dynamic with the `dynamic_axes` option.\n",
    "\n",
    "Since the values used for our dummy input are not important in this tutorial, we will set fill them with `0`.\n",
    "\n",
    "Now that we have created our dummy inputs, we are ready to call the `onnx.export()` method. We pass the method:\n",
    "- our PyTorch model,\n",
    "- the dummy inputs,\n",
    "- the name we want to give our ONNX file,\n",
    "- any dynamic axes for input and output values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "avect6dSq1ad"
   },
   "outputs": [],
   "source": [
    "torch.onnx.export(\n",
    "    model,\n",
    "    dummy_inputs,\n",
    "    \"resnet18.onnx\",\n",
    "    dynamic_axes={\"input\": {0: \"batch_size\"}, \"output\": {0: \"batch_size\"}},\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "10C2iJ8wq1ad"
   },
   "source": [
    "> For information about more export options, see the `torch.onnx.export` [documentation](https://pytorch.org/docs/stable/onnx.html#torch.onnx.export).\n",
    "\n",
    "Our PyTorch model has been successfully converted!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "kiekqBNHq1ae"
   },
   "source": [
    "### Upload the model\n",
    "\n",
    "To upload the model, we need to connect to the server using BlindAI's `core.connect()` function.\n",
    "\n",
    "Setting up a production server is not the focus of this tutorial, which is why we've been using a server in `simulation` mode. This means two things: \n",
    "\n",
    "- We also need to set the `simulation_mode` parameter to `True` on the client side. This is needed because the client will refuse to connect to an unsecure server otherwise.  \n",
    "- We also set the `hazmat_http_on_unattested_port` option to `True`. \n",
    "\n",
    "  >By default, the `blindai` package requires a HTTPS connection for communications between the client and server on the unattested port 9923. But for testing purposes we opt out of this requirement and connect without a secure connection. This should **not be done in production**, please refer to our documentation to set up a production server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rm9SJA1Wq1ag",
    "outputId": "ad720d24-6660-418f-92d2-b75a6fd1e44b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/dist-packages/blindai/client.py:506: SimulationModeWarning: BlindAI is running in simulation mode. This mode is provided solely for testing purposes. It does not provide any security since there is no SGX enclave. The simulation mode MUST NOT be used in production.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import blindai\n",
    "\n",
    "# AI company connects\n",
    "client_1 = blindai.core.connect(\n",
    "    addr=\"localhost\", simulation_mode=True, hazmat_http_on_unattested_port=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3E6s9iKqq1ag"
   },
   "source": [
    "> For the purposes of this demo, we are running the server on `localhost` using the default ports, but you can modify the host and ports in the `connect()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-19O_OO_q1ag"
   },
   "source": [
    "Finally, we can upload the model using the client `upload_model()` method! \n",
    "\n",
    "We'll need to specify the ONNX model's file name via the `model` parameter.\n",
    "\n",
    "Then we can store and print out our `model_id`, which is used to identify the model when running or deleting the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xV7GKVAZq1ah",
    "outputId": "6138d485-d6fb-4b60-c236-73cb93e6a44e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0103fbaf-f3b7-4ee2-9cfc-62d53d5b8e5c\n"
     ]
    }
   ],
   "source": [
    "# # AI company uploads model to server\n",
    "response = client_1.upload_model(model=\"./resnet18.onnx\")\n",
    "PY_MODEL_ID = response.model_id\n",
    "print(PY_MODEL_ID)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "miqufa-aq1ah"
   },
   "source": [
    "The PyTorch model has now been successfully uploaded to the BlindAI server and is ready to be consumed by users!\n",
    "\n",
    "### Testing the model\n",
    "\n",
    "As a last step, we'll perform a quick test to check the model is working as expected.\n",
    "\n",
    "To do so, we need an image to test our model with. We will take a testing image supplied by the PyTorch Hub GitHub. We take the pre-processing code provided by PyTorch to resize our image and transform it to a `torch.Tensor` as this is the expected input type for the **ResNet18** model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 248
    },
    "id": "ltJAeKKoq4Kq",
    "outputId": "93539092-7114-4004-afe6-7aa4a942b380"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torchvision import transforms\n",
    "import urllib\n",
    "from PIL import Image\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Download an example image from the pytorch website\n",
    "url, filename = (\"https://github.com/pytorch/hub/raw/master/images/dog.jpg\", \"dog.jpg\")\n",
    "try:\n",
    "    urllib.URLopener().retrieve(url, filename)\n",
    "except:\n",
    "    urllib.request.urlretrieve(url, filename)\n",
    "\n",
    "# sample execution (requires torchvision)\n",
    "input_image = Image.open(filename)\n",
    "plt.imshow(input_image)\n",
    "plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# preprocessing function to resize image and turn into tensor\n",
    "preprocess = transforms.Compose(\n",
    "    [\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "    ]\n",
    ")\n",
    "input_tensor = preprocess(input_image)\n",
    "\n",
    "\n",
    "# create a mini-batch as expected by the model\n",
    "input_batch = input_tensor.unsqueeze(0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Umjwm4EOq6ME"
   },
   "source": [
    "Now that our input is compatible, we can execute the model by using the `run_model()` method on our BlindAiConnection object, passing the model ID as the first parameter and our input Tensor as the second. We save the `RunModelResponse` in the `prediction` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "BZC-ifjUq8P6"
   },
   "outputs": [],
   "source": [
    "prediction = client_1.run_model(PY_MODEL_ID, input_batch)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "WeJO0bBKrB3Z"
   },
   "source": [
    "Next we download the labels that correspond with this pre-trained model using `requests.get()` and we convert them into a list with the `response.text.split()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "o_iika_wrFhh"
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "# get labels as list\n",
    "response = requests.get(\"https://git.io/JJkYN\")\n",
    "labels = response.text.split(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "snqrWwaRrJCS"
   },
   "source": [
    "Finally, we get the re-scale our results to get the correct output and print them out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1HC9k7ez-Uv_",
    "outputId": "896ad4b6-2970-403e-d4db-e98d0c844ef2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label is: Samoyed\n",
      "Probability is: 0.8846225142478943\n"
     ]
    }
   ],
   "source": [
    "# Get results from RunModelReponse\n",
    "output = prediction.output[0].as_torch()\n",
    "\n",
    "# Find the score in terms of percentage by using torch.nn.functional.softmax function\n",
    "# which normalizes the output to range [0,1]\n",
    "probabilities = torch.nn.functional.softmax(output, dim=1)\n",
    "\n",
    "# get index of item with highest probability\n",
    "index = probabilities.argmax().item()\n",
    "\n",
    "# get label at this index\n",
    "print(\"Label is:\", labels[index])\n",
    "\n",
    "# Get the probability- which is the highest probability from output\n",
    "print(\"Probability is:\", probabilities.max().item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "baEQkfxo-YCY"
   },
   "source": [
    "The model has correctly labelled our image as a Samoyed dog with an 88% confidence value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X5xhaka6q1ah"
   },
   "source": [
    "## TensorFlow model\n",
    "__________________________\n",
    "\n",
    "Let's now take a look at how we can convert `TensorFlow saved models` to ONNX using the [`tf2onnx.convert` tool](https://github.com/onnx/tensorflow-onnx). This is the recommended and most popular way to convert TensorFlow models to ONNX, but you can also convert to ONNX from different formats like `graphdef` or `checkpoint` format.\n",
    "\n",
    ">For more information about converting TensorFlow models from `checkpoints` or `graphdef` format, please see the [`tf2onnx` documentation](https://github.com/onnx/tensorflow-onnx).\n",
    "\n",
    "### Loading the model\n",
    "\n",
    "We'll start by loading the built-in MobileNet model, which is a computer vision model open-sourced by Google. The model returns labels for the items it has identified in the image.\n",
    "\n",
    "By importing and initializing the MobileNet class from the `keras.applications.mobilenet` module, we get back a Keras model instance of the MobileNet model. We then transform this into the SavedModel format by using the `save()` method and providing a name for our `SavedModel` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "U3QXOPSottS5",
    "outputId": "8e254a73-5e66-44df-c0f4-bad498d9afa4"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 29). These functions will not be directly callable after loading.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.applications.mobilenet import MobileNet\n",
    "\n",
    "# initalize pre-trained ResNet50 model\n",
    "model = MobileNet(weights=\"imagenet\")\n",
    "\n",
    "# compile model\n",
    "model.compile()\n",
    "\n",
    "# convert model to SavedModel format\n",
    "model.save(\"my_model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A2p66moTJkLS"
   },
   "source": [
    "A `SavedModel` is a directory, containing a `saved_model.pb` file where the TensorFlow model is stored, as well as any additional required files. Here we create our `SavedModel` directory in our current working directory and call it \"my model\".\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kd6fEAqTq1aj"
   },
   "source": [
    "### ONNX Conversion\n",
    "\n",
    "Now that we our model in `SavedModel` format we can use the `tf2onnx.convert` tool to convert our model to ONNX. We provide the path to our `saved-model` and the path we want our `output` onnx file to have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NHb9MB6Aq1aj",
    "outputId": "d8827504-aa39-4cb7-a552-b26413ee2380"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-03-23 12:33:45.236399: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "2023-03-23 12:33:45.236532: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "2023-03-23 12:33:45.236551: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n",
      "/usr/lib/python3.9/runpy.py:127: RuntimeWarning: 'tf2onnx.convert' found in sys.modules after import of package 'tf2onnx', but prior to execution of 'tf2onnx.convert'; this may result in unpredictable behaviour\n",
      "  warn(RuntimeWarning(msg))\n",
      "2023-03-23 12:33:47,403 - WARNING - '--tag' not specified for saved_model. Using --tag serve\n",
      "2023-03-23 12:33:51,008 - INFO - Signatures found in model: [serving_default].\n",
      "2023-03-23 12:33:51,008 - WARNING - '--signature_def' not specified, using first signature: serving_default\n",
      "2023-03-23 12:33:51,009 - INFO - Output names: ['predictions']\n",
      "2023-03-23 12:33:53,111 - INFO - Using tensorflow=2.11.0, onnx=1.12.0, tf2onnx=1.13.0/2c1db5\n",
      "2023-03-23 12:33:53,111 - INFO - Using opset <onnx, 13>\n",
      "2023-03-23 12:33:53,311 - INFO - Computed 0 values for constant folding\n",
      "2023-03-23 12:33:53,830 - INFO - Optimizing ONNX model\n",
      "2023-03-23 12:33:55,134 - INFO - After optimization: BatchNormalization -27 (27->0), Cast -2 (2->0), Concat -1 (1->0), Const -163 (223->60), GlobalAveragePool +1 (0->1), Identity -2 (2->0), ReduceMean -1 (1->0), Reshape -13 (14->1), Shape -1 (1->0), Slice -1 (1->0), Squeeze -1 (1->0), Transpose -122 (123->1), Unsqueeze -2 (2->0)\n",
      "2023-03-23 12:33:55,177 - INFO - \n",
      "2023-03-23 12:33:55,178 - INFO - Successfully converted TensorFlow model ./my_model to ONNX\n",
      "2023-03-23 12:33:55,178 - INFO - Model inputs: ['input_2']\n",
      "2023-03-23 12:33:55,178 - INFO - Model outputs: ['predictions']\n",
      "2023-03-23 12:33:55,178 - INFO - ONNX model is saved at ./mobilenet_tf.onnx\n"
     ]
    }
   ],
   "source": [
    "# convert SavedModel to onnx\n",
    "!python -m tf2onnx.convert --saved-model ./my_model --output ./mobilenet_tf.onnx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zg6j2YArLSkb"
   },
   "source": [
    "We now have a `mobilenet_tf.onnx` file in our current working directory ready to be uploaded to BlindAI."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VfViVf2Pq1aj"
   },
   "source": [
    "### Upload the model\n",
    "\n",
    "We are now ready to upload the model to the BlindAI server using the `upload_model` method.\n",
    "\n",
    "We then print out the model's ID which would be used later to identify the model when performing operations in the BlindAI API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SL_iJU_Qq1aj",
    "outputId": "b47aa6c6-3251-4cd0-8306-08186711c53b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/dist-packages/blindai/client.py:506: SimulationModeWarning: BlindAI is running in simulation mode. This mode is provided solely for testing purposes. It does not provide any security since there is no SGX enclave. The simulation mode MUST NOT be used in production.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b0703755-bb90-47f4-8472-cede8c898b21\n"
     ]
    }
   ],
   "source": [
    "# AI company uploads model to server\n",
    "client_1 = blindai.core.connect(\n",
    "    addr=\"localhost\", simulation_mode=True, hazmat_http_on_unattested_port=True\n",
    ")\n",
    "response = client_1.upload_model(model=\"./mobilenet_tf.onnx\")\n",
    "TF_MODEL_ID = response.model_id\n",
    "print(TF_MODEL_ID)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "_fcjWnhrGa2k"
   },
   "source": [
    "### Testing the model\n",
    "\n",
    "Let's test the model is working as expected. \n",
    "\n",
    "To do so, we'll download a testing image provided by TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "vPtLjVvt7Fja",
    "outputId": "ea079194-ae09-4721-af52-b5e029d685fe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 223.5, 223.5, -0.5)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "# get image for testing\n",
    "file = tf.keras.utils.get_file(\n",
    "    \"grace_hopper.jpg\",\n",
    "    \"https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg\",\n",
    ")\n",
    "\n",
    "# load image to desired size\n",
    "img = tf.keras.utils.load_img(file, target_size=[224, 224])\n",
    "\n",
    "# display image for tutorial\n",
    "plt.imshow(img)\n",
    "plt.axis(\"off\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "cHffg5zmGo6A"
   },
   "source": [
    "Next, we need to perform the necessary pre-processing on the image. First, we need to convert our image to numpy.ndarray format using the `image_to_array()` method provided to us in `keras.utils`. \n",
    "\n",
    "We then can use a MobileNet-specific pre-processing method provided built into `keras.application` to ensure our image is compatible with the model- we also add a new axis to the image so that its dimensions are as expected by the MobileNet model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "id": "fnpQwBjZGpKf"
   },
   "outputs": [],
   "source": [
    "# convert image to numpy.ndarray\n",
    "x = tf.keras.utils.img_to_array(img)\n",
    "\n",
    "# add dimension and perform necessary preprocessing\n",
    "x = tf.keras.applications.mobilenet.preprocess_input(x[tf.newaxis, ...])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "H0ZPYBliH7Hb"
   },
   "source": [
    "Next up, we need to download a file containing the labels for this model and convert them into a `numpy.ndarray`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "id": "VQAndRya7OXw"
   },
   "outputs": [],
   "source": [
    "# get labels\n",
    "labels_path = tf.keras.utils.get_file(\n",
    "    \"ImageNetLabels.txt\",\n",
    "    \"https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt\",\n",
    ")\n",
    "\n",
    "# create array of labels from file\n",
    "imagenet_labels = np.array(open(labels_path).read().splitlines())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "ykZ9UEU_IVCd"
   },
   "source": [
    "Now that we have prepared our input and labels, we are ready to run the model in BlindAI.\n",
    "\n",
    "We use the `run_model()` method on our `BlindAI Connection` object, providing the ID of our model and our input image.\n",
    "\n",
    "We get the output of the model as a `numpy.ndarray`.\n",
    "\n",
    "We order labels by confidence interval of a match and take the top 5 results. We must apply an offset of +1 in order for these indices to match up correctly with the labels. Then we print out the corresponding labels for our indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "noeG8Y0G7StP",
    "outputId": "b472a6c4-a3a3-4f32-e957-b696ab912a3b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result after saving and loading:\n",
      " ['military uniform' 'bow tie' 'suit' 'bearskin' 'pickelhaube']\n"
     ]
    }
   ],
   "source": [
    "# run model on our input image in BlindAI\n",
    "ret = client_1.run_model(TF_MODEL_ID, x)\n",
    "\n",
    "# convert results to numpy ndarray\n",
    "output = ret.output[0].as_numpy()\n",
    "\n",
    "# Get indices for top 5 most probable labels, apply offset\n",
    "indices = np.argsort(output)[0, ::-1][:5] + 1\n",
    "\n",
    "# decode results\n",
    "decoded = imagenet_labels[indices]\n",
    "print(\"Result after saving and loading:\\n\", decoded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FxyyWHkmNR4x"
   },
   "source": [
    "In this case, the top three labels correctly identify elements from out image.\n",
    "\n",
    ">Note that exported ONNX models must be compatible with the Rust crate `tract-onnx` to be executed in BlindAI. If you are experiencing issues, we recommend using PyTorch models for maximum compatibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_rkpY7ulq1am"
   },
   "source": [
    "## Conclusions\n",
    "____________________________________\n",
    "\n",
    "This is the end of our tutorial on uploading models to BlindAI.\n",
    "\n",
    "We have seen how to:\n",
    "\n",
    "* **Convert** PyTorch and TensorFlow models to ONNX format.\n",
    "* **Upload** these models to BlindAI.\n",
    "* **Run** these models in BlindAI.\n",
    "\n",
    "Please check out the rest of our [BlindAI documentation](https://blindai.mithrilsecurity.io/en/latest/) to see more examples of how you can use BlindAI to deploy AI models without compromising the safety of user data or models."
   ]
  }
 ],
 "metadata": {
    "mkdocs": {
        "description": "Upload and test ML models securely on BlindAI server: Ensure user data privacy and security during AI model deployment."
    },
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
